package rht

import (
	"bytes"
	"encoding/json"
	"encoding/xml"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"net/netip"
	"os"
	"strconv"
	"strings"

	"github.com/go-playground/form/v4"
)

func NewHttpServerRequest(r *http.Request) HttpServerRequestFunc {
	return &httpServerRequestFunc{req: r}
}

var _ HttpServerRequestFunc = new(httpServerRequestFunc)

type HttpServerRequestFunc interface {
	Request() *http.Request

	// GetIP 获取客户端IP地址
	GetIP() string
	// GetRemoteAddrIP 获取客户端/反向代理服务器IP，如果有反向代理，则获取的是服务器的IP。
	GetRemoteAddrIP() string
	// GetTrueClientIP 获取真实客户端IP，前提是反向代理里面设置了头 "True-Client-IP"
	GetTrueClientIP() string
	// GetXRealIP 获取真实客户端IP，前提是反向代理里面设置了头 "X-Real-Ip"
	GetXRealIP() string
	// GetXForwardedForIP 获取相对真实的客户端IP，前提是反向代理里面设置了头 "X-Forwarded-For"
	GetXForwardedForIP() string

	// ReadBody 获取全部请求体，只能调用一次，第二次会读取不到内容。
	ReadBody() ([]byte, error)
	// CloneBody 克隆全部请求体，不宜克隆body大的请求体。
	CloneBody() ([]byte, error)
	// ReadQuery 读取请求查询参数，并且值绑定到obj
	ReadQuery(obj any, skipVerify ...bool) error
	// ReadQueryByTag 读取请求查询参数，并且值绑定到obj，tag为绑定的tag
	ReadQueryByTag(obj any, tag string, skipVerify ...bool) error
	// ReadForm 读取请求表单参数，并且值绑定到obj
	ReadForm(obj any, skipVerify ...bool) error
	// ReadFormByTag 读取请求表单参数，并且值绑定到obj，tag为绑定的tag
	ReadFormByTag(obj any, tag string, skipVerify ...bool) error
	// ReadPostForm 读取请求表单参数，并且值绑定到obj
	ReadPostForm(obj any, skipVerify ...bool) error
	// ReadPostFormByTag 读取请求表单参数，并且值绑定到obj，tag为绑定的tag
	ReadPostFormByTag(obj any, tag string, skipVerify ...bool) error
	// ReadJSON 读取请求体，并且JSON解码，只能调用一次，第二次会读取不到内容。
	ReadJSON(obj any, skipVerify ...bool) error
	// ReadXML 读取请求体，并且XML解码，只能调用一次，第二次会读取不到内容。
	ReadXML(obj any, skipVerify ...bool) error

	// GetFormFile 获取表单文件
	GetFormFile(name string) (multipart.File, *multipart.FileHeader, error)
	// GetFormFileSave 获取表单文件，并且保存到本地
	GetFormFileSave(name string, saveName string) (int64, error)
	// SaveFormFile 保存表单文件
	SaveFormFile(fh *multipart.FileHeader, saveName string) (int64, error)
	// GetQuery 获取URL查询参数
	GetQuery(key string) string
	// GetFormValue 获取URL查询参数
	GetFormValue(key string) string
	// GetPostFormValue 获取请求体表单参数
	GetPostFormValue(key string) string
	// GetPathValue 获取URL路径参数
	GetPathValue(key string) string
	// GetBasicAuth 获取Basic认证信息
	GetBasicAuth() (username, password string, ok bool)
	// GetPath 获取请求路径
	GetPath() string
	// GetURI 获取请求路径和查询参数
	GetURI() string
	// GetHost 获取Host
	GetHost() string
	// GetMethod 获取请求方法
	GetMethod() string
	// GetProto 获取请求协议
	GetProto() string
	// GetHeader 获取请求头
	GetHeader() http.Header
	// GetUserAgent 获取UserAgent
	GetUserAgent() string
	// GetXRequestID 获取请求头 "X-Request-Id"
	GetXRequestID() string
	// GetAuthorization 获取请求头 "Authorization"
	GetAuthorization() string
	// GetAuthorizationBearer 获取请求头 "Authorization"，并且去掉 "Bearer " 前缀。
	GetAuthorizationBearer() string
	// GetXCSRFToken 获取请求头 "X-CSRF-Token"
	GetXCSRFToken() string

	// GetQueryString 获取URL查询参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetQueryString(key string, def ...string) string
	// GetFormValueString 获取URL查询参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetFormValueString(key string, def ...string) string
	// GetPostFormValueString 获取请求体表单参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetPostFormValueString(key string, def ...string) string
	// GetPathValueString 获取URL路径参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetPathValueString(key string, def ...string) string

	// GetQueryInt 获取URL查询参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetQueryInt(key string, def ...int) int
	// GetFormValueInt 获取URL查询参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetFormValueInt(key string, def ...int) int
	// GetPostFormValueInt 获取请求体表单参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetPostFormValueInt(key string, def ...int) int
	// GetPathValueInt 获取URL路径参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetPathValueInt(key string, def ...int) int

	// GetQueryUint 获取URL查询参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetQueryUint(key string, def ...uint) uint
	// GetFormValueUint 获取URL查询参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetFormValueUint(key string, def ...uint) uint
	// GetPostFormValueUint 获取请求体表单参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetPostFormValueUint(key string, def ...uint) uint
	// GetPathValueUint 获取URL路径参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetPathValueUint(key string, def ...uint) uint

	// GetQueryInt64 获取URL查询参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetQueryInt64(key string, def ...int64) int64
	// GetFormValueInt64 获取URL查询参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetFormValueInt64(key string, def ...int64) int64
	// GetPostFormValueInt64 获取请求体表单参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetPostFormValueInt64(key string, def ...int64) int64
	// GetPathValueInt64 获取URL路径参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetPathValueInt64(key string, def ...int64) int64

	// GetQueryUint64 获取URL查询参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetQueryUint64(key string, def ...uint64) uint64
	// GetFormValueUint64 获取URL查询参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetFormValueUint64(key string, def ...uint64) uint64
	// GetPostFormValueUint64 获取请求体表单参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetPostFormValueUint64(key string, def ...uint64) uint64
	// GetPathValueUint64 获取URL路径参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetPathValueUint64(key string, def ...uint64) uint64

	// GetQueryFloat64 获取URL查询参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetQueryFloat64(key string, def ...float64) float64
	// GetFormValueFloat64 获取URL查询参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetFormValueFloat64(key string, def ...float64) float64
	// GetPostFormValueFloat64 获取请求体表单参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetPostFormValueFloat64(key string, def ...float64) float64
	// GetPathValueFloat64 获取URL路径参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetPathValueFloat64(key string, def ...float64) float64

	// GetQueryBool 获取URL查询参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetQueryBool(key string, def ...bool) bool
	// GetFormValueBool 获取URL查询参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetFormValueBool(key string, def ...bool) bool
	// GetPostFormValueBool 获取请求体表单参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetPostFormValueBool(key string, def ...bool) bool
	// GetPathValueBool 获取URL路径参数，如果不存在或错误，则随机返回def的任意一个，或者默认值。
	GetPathValueBool(key string, def ...bool) bool

	// ContextValue 获取上下文参数
	ContextValue(key any) any
	ContextValueString(key any, def ...string) string
	ContextValueInt(key any, def ...int) int
	ContextValueInt64(key any, def ...int64) int64
	ContextValueUint(key any, def ...uint) uint
	ContextValueUint64(key any, def ...uint64) uint64
	ContextValueFloat64(key any, def ...float64) float64
	ContextValueBool(key any, def ...bool) bool
}

type httpServerRequestFunc struct {
	req *http.Request
	ip  string
}

func (r *httpServerRequestFunc) Request() *http.Request {
	return r.req
}

func (r *httpServerRequestFunc) GetIP() string {
	if r.ip != "" {
		return r.ip
	}
	if ip := r.GetTrueClientIP(); ip != "" {
		r.ip = ip
		return r.ip
	}
	if ip := r.GetXRealIP(); ip != "" {
		r.ip = ip
		return r.ip
	}
	if ip := r.GetXForwardedForIP(); ip != "" {
		r.ip = ip
		return r.ip
	}
	r.ip = r.GetRemoteAddrIP()
	return r.ip
}

func (r *httpServerRequestFunc) GetRemoteAddrIP() string {
	addrPort, err := netip.ParseAddrPort(r.req.RemoteAddr)
	if err != nil {
		return ""
	}
	return addrPort.Addr().String()
}

func (r *httpServerRequestFunc) GetTrueClientIP() string {
	return r.req.Header.Get(trueClientIP)
}

func (r *httpServerRequestFunc) GetXRealIP() string {
	return r.req.Header.Get(xRealIP)
}

func (r *httpServerRequestFunc) GetXForwardedForIP() string {
	xffIP := r.req.Header.Get(xForwardedFor)
	if xffIP == "" {
		return ""
	} else {
		i := strings.Index(xffIP, ",")
		if i == -1 {
			i = len(xffIP)
		}
		return xffIP[:i]
	}
}

func (r *httpServerRequestFunc) ReadBody() ([]byte, error) {
	body, err := io.ReadAll(r.req.Body)
	if err != nil {
		return nil, err
	}
	_ = r.req.Body.Close()
	return body, nil
}

func (r *httpServerRequestFunc) CloneBody() ([]byte, error) {
	body, err := io.ReadAll(r.req.Body)
	if err != nil {
		return nil, err
	}
	_ = r.req.Body.Close()
	r.req.Body = io.NopCloser(bytes.NewBuffer(body))
	return body, nil
}

func (r *httpServerRequestFunc) ReadQuery(obj any, skipVerify ...bool) error {
	err := _queryDecoder.Decode(obj, r.req.URL.Query())
	if err != nil {
		return err
	}
	if len(skipVerify) > 0 {
		if skipVerify[0] == true {
			return nil
		}
	}
	return _Validator.Struct(obj)
}

func (r *httpServerRequestFunc) ReadQueryByTag(obj any, tag string, skipVerify ...bool) error {
	decoder := form.NewDecoder()
	decoder.SetTagName(tag)
	err := decoder.Decode(obj, r.req.URL.Query())
	if err != nil {
		return err
	}
	if len(skipVerify) > 0 {
		if skipVerify[0] == true {
			return nil
		}
	}
	return _Validator.Struct(obj)
}

func (r *httpServerRequestFunc) ReadForm(obj any, skipVerify ...bool) error {
	_ = r.req.ParseForm()
	err := _queryDecoder.Decode(obj, r.req.Form)
	if err != nil {
		return err
	}
	if len(skipVerify) > 0 {
		if skipVerify[0] == true {
			return nil
		}
	}
	return _Validator.Struct(obj)
}

func (r *httpServerRequestFunc) ReadFormByTag(obj any, tag string, skipVerify ...bool) error {
	_ = r.req.ParseForm()
	decoder := form.NewDecoder()
	decoder.SetTagName(tag)
	err := decoder.Decode(obj, r.req.Form)
	if err != nil {
		return err
	}
	if len(skipVerify) > 0 {
		if skipVerify[0] == true {
			return nil
		}
	}
	return _Validator.Struct(obj)
}

func (r *httpServerRequestFunc) ReadPostForm(obj any, skipVerify ...bool) error {
	_ = r.req.ParseForm()
	err := _queryDecoder.Decode(obj, r.req.PostForm)
	if err != nil {
		return err
	}
	if len(skipVerify) > 0 {
		if skipVerify[0] == true {
			return nil
		}
	}
	return _Validator.Struct(obj)
}

func (r *httpServerRequestFunc) ReadPostFormByTag(obj any, tag string, skipVerify ...bool) error {
	_ = r.req.ParseForm()
	decoder := form.NewDecoder()
	decoder.SetTagName(tag)
	err := decoder.Decode(obj, r.req.PostForm)
	if err != nil {
		return err
	}
	if len(skipVerify) > 0 {
		if skipVerify[0] == true {
			return nil
		}
	}
	return _Validator.Struct(obj)
}

func (r *httpServerRequestFunc) ReadJSON(obj any, skipVerify ...bool) error {
	body, err := r.ReadBody()
	if err != nil {
		return err
	}
	err = json.Unmarshal(body, obj)
	if err != nil {
		return err
	}
	if len(skipVerify) > 0 {
		if skipVerify[0] == true {
			return nil
		}
	}
	return _Validator.Struct(obj)
}

func (r *httpServerRequestFunc) ReadXML(obj any, skipVerify ...bool) error {
	body, err := r.ReadBody()
	if err != nil {
		return err
	}
	err = xml.Unmarshal(body, obj)
	if err != nil {
		return err
	}
	if len(skipVerify) > 0 {
		if skipVerify[0] == true {
			return nil
		}
	}
	return _Validator.Struct(obj)
}

func (r *httpServerRequestFunc) GetFormFile(name string) (multipart.File, *multipart.FileHeader, error) {
	return r.req.FormFile(name)
}

func (r *httpServerRequestFunc) GetFormFileSave(name string, saveName string) (int64, error) {
	_, fh, err := r.req.FormFile(name)
	if err != nil {
		return 0, err
	}
	return r.SaveFormFile(fh, saveName)
}

func (r *httpServerRequestFunc) SaveFormFile(fh *multipart.FileHeader, saveName string) (int64, error) {
	src, err := fh.Open()
	if err != nil {
		return 0, err
	}
	defer src.Close()
	out, err := os.Create(saveName)
	if err != nil {
		return 0, err
	}
	defer out.Close()
	return io.Copy(out, src)
}

func (r *httpServerRequestFunc) GetQuery(key string) string {
	return r.req.FormValue(key)
}

func (r *httpServerRequestFunc) GetFormValue(key string) string {
	return r.req.FormValue(key)
}

func (r *httpServerRequestFunc) GetPostFormValue(key string) string {
	return r.req.PostFormValue(key)
}

func (r *httpServerRequestFunc) GetPathValue(key string) string {
	return r.req.PathValue(key)
}

func (r *httpServerRequestFunc) GetBasicAuth() (username, password string, ok bool) {
	return r.req.BasicAuth()
}

func (r *httpServerRequestFunc) GetPath() string {
	return r.req.URL.Path
}

func (r *httpServerRequestFunc) GetURI() string {
	return r.req.URL.RequestURI()
}

func (r *httpServerRequestFunc) GetHost() string {
	return r.req.Host
}

func (r *httpServerRequestFunc) GetMethod() string {
	return r.req.Method
}

func (r *httpServerRequestFunc) GetProto() string {
	return r.req.Proto
}

func (r *httpServerRequestFunc) GetHeader() http.Header {
	return r.req.Header
}

func (r *httpServerRequestFunc) GetUserAgent() string {
	return r.req.UserAgent()
}

func (r *httpServerRequestFunc) GetXRequestID() string {
	return r.req.Header.Get(xRequestID)
}

func (r *httpServerRequestFunc) GetAuthorization() string {
	return r.req.Header.Get(authorization)
}

func (r *httpServerRequestFunc) GetAuthorizationBearer() string {
	token := r.GetAuthorization()
	if strings.HasPrefix(token, "Bearer ") {
		return token[7:]
	}
	return token
}

func (r *httpServerRequestFunc) GetXCSRFToken() string {
	return r.req.Header.Get(xCSRFToken)
}

func (r *httpServerRequestFunc) GetQueryString(key string, def ...string) string {
	i := r.req.FormValue(key)
	if i == "" {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return ""
	}
	return i
}

func (r *httpServerRequestFunc) GetFormValueString(key string, def ...string) string {
	i := r.req.FormValue(key)
	if i == "" {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return ""
	}
	return i
}

func (r *httpServerRequestFunc) GetPostFormValueString(key string, def ...string) string {
	i := r.req.PostFormValue(key)
	if i == "" {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return ""
	}
	return i
}

func (r *httpServerRequestFunc) GetPathValueString(key string, def ...string) string {
	i := r.req.PathValue(key)
	if i == "" {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return ""
	}
	return i
}

func (r *httpServerRequestFunc) GetQueryInt(key string, def ...int) int {
	i, err := strconv.Atoi(r.req.FormValue(key))
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return i
}

func (r *httpServerRequestFunc) GetFormValueInt(key string, def ...int) int {
	i, err := strconv.Atoi(r.req.FormValue(key))
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return i
}

func (r *httpServerRequestFunc) GetPostFormValueInt(key string, def ...int) int {
	i, err := strconv.Atoi(r.req.PostFormValue(key))
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return i
}

func (r *httpServerRequestFunc) GetPathValueInt(key string, def ...int) int {
	i, err := strconv.Atoi(r.req.PathValue(key))
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return i
}

func (r *httpServerRequestFunc) GetQueryUint(key string, def ...uint) uint {
	i, err := strconv.ParseUint(r.req.FormValue(key), 10, 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return uint(i)
}

func (r *httpServerRequestFunc) GetFormValueUint(key string, def ...uint) uint {
	i, err := strconv.ParseUint(r.req.FormValue(key), 10, 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return uint(i)
}

func (r *httpServerRequestFunc) GetPostFormValueUint(key string, def ...uint) uint {
	i, err := strconv.ParseUint(r.req.PostFormValue(key), 10, 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return uint(i)
}

func (r *httpServerRequestFunc) GetPathValueUint(key string, def ...uint) uint {
	i, err := strconv.ParseUint(r.req.PathValue(key), 10, 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return uint(i)
}

func (r *httpServerRequestFunc) GetQueryInt64(key string, def ...int64) int64 {
	i, err := strconv.ParseInt(r.req.FormValue(key), 10, 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return i
}

func (r *httpServerRequestFunc) GetFormValueInt64(key string, def ...int64) int64 {
	i, err := strconv.ParseInt(r.req.FormValue(key), 10, 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return i
}

func (r *httpServerRequestFunc) GetPostFormValueInt64(key string, def ...int64) int64 {
	i, err := strconv.ParseInt(r.req.PostFormValue(key), 10, 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return i
}

func (r *httpServerRequestFunc) GetPathValueInt64(key string, def ...int64) int64 {
	i, err := strconv.ParseInt(r.req.PathValue(key), 10, 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return i
}

func (r *httpServerRequestFunc) GetQueryUint64(key string, def ...uint64) uint64 {
	i, err := strconv.ParseUint(r.req.FormValue(key), 10, 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return i
}

func (r *httpServerRequestFunc) GetFormValueUint64(key string, def ...uint64) uint64 {
	i, err := strconv.ParseUint(r.req.FormValue(key), 10, 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return i
}

func (r *httpServerRequestFunc) GetPostFormValueUint64(key string, def ...uint64) uint64 {
	i, err := strconv.ParseUint(r.req.PostFormValue(key), 10, 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return i
}

func (r *httpServerRequestFunc) GetPathValueUint64(key string, def ...uint64) uint64 {
	i, err := strconv.ParseUint(r.req.PathValue(key), 10, 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return i
}

func (r *httpServerRequestFunc) GetQueryFloat64(key string, def ...float64) float64 {
	i, err := strconv.ParseFloat(r.req.FormValue(key), 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return i
}

func (r *httpServerRequestFunc) GetFormValueFloat64(key string, def ...float64) float64 {
	i, err := strconv.ParseFloat(r.req.FormValue(key), 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return i
}

func (r *httpServerRequestFunc) GetPostFormValueFloat64(key string, def ...float64) float64 {
	i, err := strconv.ParseFloat(r.req.PostFormValue(key), 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return i
}

func (r *httpServerRequestFunc) GetPathValueFloat64(key string, def ...float64) float64 {
	i, err := strconv.ParseFloat(r.req.PathValue(key), 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return i
}

func (r *httpServerRequestFunc) GetQueryBool(key string, def ...bool) bool {
	i, err := strconv.ParseBool(r.req.FormValue(key))
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return false
	}
	return i
}

func (r *httpServerRequestFunc) GetFormValueBool(key string, def ...bool) bool {
	i, err := strconv.ParseBool(r.req.FormValue(key))
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return false
	}
	return i
}

func (r *httpServerRequestFunc) GetPostFormValueBool(key string, def ...bool) bool {
	i, err := strconv.ParseBool(r.req.PostFormValue(key))
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return false
	}
	return i
}

func (r *httpServerRequestFunc) GetPathValueBool(key string, def ...bool) bool {
	i, err := strconv.ParseBool(r.req.PathValue(key))
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return false
	}
	return i
}

func (r *httpServerRequestFunc) ContextValue(key any) any {
	return r.req.Context().Value(key)
}

func (r *httpServerRequestFunc) ContextValueString(key any, def ...string) string {
	if v, bl := r.req.Context().Value(key).(string); bl {
		return v
	} else {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return ""
	}
}

func (r *httpServerRequestFunc) ContextValueInt(key any, def ...int) int {
	if v, bl := r.req.Context().Value(key).(int); bl {
		return v
	}
	parseInt, err := strconv.ParseInt(fmt.Sprint(r.req.Context().Value(key)), 10, 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return int(parseInt)
}

func (r *httpServerRequestFunc) ContextValueInt64(key any, def ...int64) int64 {
	if v, bl := r.req.Context().Value(key).(int64); bl {
		return v
	}
	parseInt, err := strconv.ParseInt(fmt.Sprint(r.req.Context().Value(key)), 10, 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return parseInt
}

func (r *httpServerRequestFunc) ContextValueUint(key any, def ...uint) uint {
	if v, bl := r.req.Context().Value(key).(uint); bl {
		return v
	}
	parseUint, err := strconv.ParseUint(fmt.Sprint(r.req.Context().Value(key)), 10, 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return uint(parseUint)
}

func (r *httpServerRequestFunc) ContextValueUint64(key any, def ...uint64) uint64 {
	if v, bl := r.req.Context().Value(key).(uint64); bl {
		return v
	}
	parseUint, err := strconv.ParseUint(fmt.Sprint(r.req.Context().Value(key)), 10, 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return parseUint
}

func (r *httpServerRequestFunc) ContextValueFloat64(key any, def ...float64) float64 {
	if v, bl := r.req.Context().Value(key).(float64); bl {
		return v
	}
	parseFloat, err := strconv.ParseFloat(fmt.Sprint(r.req.Context().Value(key)), 64)
	if err != nil {
		if len(def) == 1 {
			return def[0]
		} else if len(def) > 1 {
			return def[_Rand.IntN(len(def))]
		}
		return 0
	}
	return parseFloat
}

func (r *httpServerRequestFunc) ContextValueBool(key any, def ...bool) bool {
	switch fmt.Sprint(r.req.Context().Value(key)) {
	case "0":
		return false
	case "1":
		return true
	case "false":
		return false
	case "true":
		return true
	default:
		parseBool, err := strconv.ParseBool(fmt.Sprint(r.req.Context().Value(key)))
		if err != nil {
			if len(def) == 1 {
				return def[0]
			} else if len(def) > 1 {
				return def[_Rand.IntN(len(def))]
			}
			return false
		}
		return parseBool
	}
}
